/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.vertigo.fever;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;

import javax.microedition.khronos.opengles.GL10;

/**
 * A vertex shaded cube.
 */
class Ship
{
	Vector position = new Vector();
	Vector offset = new Vector(0,0.5f,0); // up a little so sits on tiles 
	float rotate = 0;
	
	public void reset() {
		position.x = -3 * Tile.WIDTH; // on third tile 
		position.y = 0;
		position.z = 0;
	}
//	float X = 5257.31112119133606f;
//	float Z = 8506.50808352039932f;

	int X = 52573 / 2;
	int Z = 85065 / 2;
	int ZERO = 0;
	
	
	boolean alert = false;
	
    public Ship() {
    	
    	position = new Vector(0,0,0);
    	reset();
    	
        int vertices[] = {
        		-X, ZERO, Z, 
        		X, ZERO, Z, 
        		-X, ZERO, -Z, 
        		X, ZERO, -Z,    
        		ZERO, Z, X, 
        		ZERO, Z, -X, 
        		ZERO, -Z, X, 
        		ZERO, -Z, -X,    
        		Z, X, ZERO, 
        		-Z, X, ZERO, 
        		Z, -X, ZERO, 
        		-Z, -X, ZERO 
        };
        
//    	int x = 10000;
//    	int y = 10000;
//    	int z = 10000;
//        
//    	int vertices[] = {
//                -x, -y, -z,
//                x, -y, -z, 
//                x,  y, -z, 
//                -x,  y, -z,
//                -x, -y,  z,
//                x, -y,  z,
//                x,  y,  z,
//                -x,  y,  z,
//        };

        int one = 0x10000;
        int colors[] = {
                0,    0,    0,  one,
                one,    0,    0,  one,
                one,  one,    0,  one,
                0,  one,    0,  one,
                0,    0,  one,  one,
                one,    0,  one,  one,
                one,  one,  one,  one,
                0,  one,  one,  one,
                0,    0,    0,  one,
                one,    0,    0,  one,
                one,  one,    0,  one,
                0,  one,    0,  one,
        };
        
        int red_colors[] = {
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
                one,    0,    0,  one,
        };

        byte indices[] = {
        		0,4,1, 0,9,4, 9,5,4, 4,5,8, 4,8,1,    
        		8,10,1, 8,3,10, 5,3,8, 5,2,3, 2,7,3,    
        		7,10,3, 7,6,10, 7,11,6, 11,0,6, 0,1,6, 
        		6,1,10, 9,0,11, 9,11,2, 9,2,5, 7,2,11 
        };
//        byte indices[] = {
//                0, 4, 5,    0, 5, 1,
//                1, 5, 6,    1, 6, 2,
//                2, 6, 7,    2, 7, 3,
//                3, 7, 4,    3, 4, 0,
//                4, 7, 6,    4, 6, 5,
//                3, 0, 1,    3, 1, 2
//        };

        // Buffers to be passed to gl*Pointer() functions
        // must be direct, i.e., they must be placed on the
        // native heap where the garbage collector cannot
        // move them.
        //
        // Buffers with multi-byte datatypes (e.g., short, int, float)
        // must have their byte order set to native order


        mVertexBuffer = createIntBuffer(vertices);
        mColorBuffer = createIntBuffer(colors);
        mColorBufferAlert = createIntBuffer(red_colors);

        mIndexBuffer = ByteBuffer.allocateDirect(indices.length);
        mIndexBuffer.put(indices);
        mIndexBuffer.position(0);
    }

	private IntBuffer createIntBuffer(int[] colors) {
		ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length*4);
        cbb.order(ByteOrder.nativeOrder());
        IntBuffer intBuffer = cbb.asIntBuffer();
        intBuffer.put(colors);
        intBuffer.position(0);
        return intBuffer;
	}

    public void draw(GL10 gl)
    {
    	gl.glTranslatef(offset.x, offset.y, offset.z);
        gl.glRotatef(rotate, 1, 0, 0);
        gl.glFrontFace(gl.GL_CW);
        gl.glVertexPointer(3, gl.GL_FIXED, 0, mVertexBuffer);
        gl.glColorPointer(4, gl.GL_FIXED, 0, alert?mColorBufferAlert:mColorBuffer);
        gl.glDrawElements(gl.GL_TRIANGLES, 36, gl.GL_UNSIGNED_BYTE, mIndexBuffer);
        gl.glRotatef(-rotate, 1, 0, 0);
    	gl.glTranslatef(-offset.x, -offset.y, -offset.z);
    }
	
    private IntBuffer   mVertexBuffer;
    private IntBuffer   mColorBuffer;
    private IntBuffer   mColorBufferAlert;
    private ByteBuffer  mIndexBuffer;
}
